home *** CD-ROM | disk | FTP | other *** search
/ Total Network Tools 2002 / NextStepPublishing-TotalNetworkTools2002-Win95.iso / Archive / Misc Servers / Zope.exe / DUMBLISPGEN.PY < prev    next >
Encoding:
Text File  |  1999-07-28  |  7.0 KB  |  237 lines
  1.  
  2. #
  3. # test for kjParseBuild module automatic parser generation
  4. #
  5. # lisp lists with strings, ints, vars, and setq
  6.  
  7. import string
  8.  
  9. ### The string representation for the grammar.
  10. ### Since this is used only by GrammarBuild()
  11. ### it could be put in a separate file with GrammarBuild()
  12. ### to save space/load time after Grammar compilation.
  13. ###
  14. GRAMMARSTRING ="""
  15.        Value ::  ## indicates Value is the root nonterminal for the grammar
  16.          @R SetqRule :: Value >> ( setq var Value )
  17.          @R ListRule :: Value >> ( ListTail
  18.          @R TailFull :: ListTail >> Value ListTail
  19.          @R TailEmpty :: ListTail >> )
  20.          @R Varrule :: Value >> var
  21.          @R Intrule :: Value >> int
  22.          @R Strrule :: Value >> str
  23. """
  24.  
  25. ### the name of the file in which to create the compiled
  26. ### grammar declarations
  27. COMPILEDFILENAME = "TESTLispG2.py"
  28.  
  29. ### declare comment form(s) as regular expressions 
  30. LISPCOMMENTREGEX = ";.*"
  31.  
  32. ### declare regular expression string constants for terminals
  33.  
  34. #integer terminal::::::: 
  35. INTREGEX = "["+string.digits+"]+"
  36.  
  37. #string terminal:::::::: 
  38. STRREGEX = '"[^\n"]*"'
  39.  
  40. #var terminal:::::::: 
  41. VARREGEX = "["+string.letters+"]["+string.letters+string.digits+"]*"
  42.  
  43. ### declare interpretation functions for terminals
  44.  
  45. # int interpretation function: translates string to int: 
  46. # Could use string.atoi without the extra level of indirection 
  47. # but for demo purposes here it is.  
  48. # 
  49. def intInterp( str ):
  50.    return string.atoi(str)
  51.  
  52. # interpretation function for strings strips off the surrounding quotes.  
  53. def stripQuotes( str ):
  54.    if len(str)<2:
  55.       TypeError, "string too short?"
  56.    return str[1:len(str)-1]
  57.  
  58. # interpretation function for vars just returns the recognized string
  59. def echo(string):
  60.    return string
  61.  
  62. # This function declares the nonterminals both in the 
  63. # "grammar generation phase" and in loading the compiled 
  64. # grammar after generation 
  65. # 
  66. def DeclareTerminals(Grammar):
  67.    Grammar.Addterm("int", INTREGEX, intInterp)
  68.    Grammar.Addterm("str", STRREGEX, stripQuotes)
  69.    Grammar.Addterm("var", VARREGEX, echo)
  70.  
  71. ### declare the rule reduction interpretation functions.
  72.  
  73. # EchoValue() serves for Intrule and Strrule, since 
  74. # we just want to echo the value returned by the 
  75. # respective terminal interpretation functions.  
  76. # 
  77. # Parser delivers list of form [ interpreted_value ] 
  78. def EchoValue( list, Context ):
  79.    if len(list)!=1:
  80.       raise TypeError, "this shouldn't happen! (1)"
  81.    return list[0]
  82.  
  83. # for Varrule interpreter must try to look up the value 
  84. # in the Context dictionary 
  85. # 
  86. # Parser delivers list of form [ var_name ] 
  87. def VarValue( list, Context ):
  88.    if len(list)!=1:
  89.       raise TypeError, "Huh? (2)"
  90.    varName = list[0]
  91.    if Context.has_key(varName):
  92.       return Context[varName]
  93.    else:
  94.       raise NameError, "no such lisp variable in context "+varName
  95.  
  96. # for an empty tail, return the empty list 
  97. # 
  98. # Parser delivers list of form [")"] 
  99. def NilTail( list, Context ):
  100.    if len(list) != 1 or list[0] != ")":
  101.       return TypeError, "Bad reduction?"
  102.    return []
  103.  
  104. # For a full tail, add the new element to the front of the list 
  105. # 
  106. # Parser delivers list of form [Value, TailValue] 
  107. def AddToList( list, Context ):
  108.    if len(list) !=2:
  109.       return TypeError, "Bad reduction?"
  110.    return [ list[0] ] + list[1]
  111.  
  112. # For a list, simply return the list determined by the tail 
  113. # 
  114. # Parser delivers list of form ["(", TailValue ] 
  115. def MakeList( list, Context ):
  116.    if len(list)!=2 or list[0]!="(":
  117.       raise TypeError, "Bad reduction? (3)"
  118.    return list[1]
  119.  
  120. # For a setq, declare a new variable in the Context dictionary 
  121. # 
  122. # Parser delivers list of form # ["(", "setq", varName, Value, ")"] 
  123. def DoSetq( list, Context):
  124.    if len(list) != 5\
  125.      or list[0] != "("\
  126.      or list[1] != "setq"\
  127.      or list[4] != ")":
  128.       print list
  129.       raise TypeError, "Bad reduction? (4)"
  130.    VarName = list[2]
  131.    if type(VarName) != type(''):
  132.       raise TypeError, "Bad var name? (5)"
  133.    Value = list[3]
  134.    # add or set the variable in the Context dictionary
  135.    Context[ VarName ] = Value
  136.    return Value
  137.  
  138. # This function Binds the named rules of the Grammar string to their 
  139. # interpretation functions in a Grammar.  
  140. # 
  141. def BindRules(Grammar):
  142.     Grammar.Bind( "Intrule", EchoValue )
  143.     Grammar.Bind( "Strrule", EchoValue )
  144.     Grammar.Bind( "Varrule", VarValue )
  145.     Grammar.Bind( "TailEmpty", NilTail )
  146.     Grammar.Bind( "TailFull", AddToList )
  147.     Grammar.Bind( "ListRule", MakeList )
  148.     Grammar.Bind( "SetqRule", DoSetq )
  149.  
  150. # This function generates the grammar and dumps it to a file.  
  151. # Since it will be used only once (after debugging), 
  152. # it probably should be put in another file save memory/load-time.  
  153. #
  154. # the result returned is a Grammar Object that can be used 
  155. # for testing/debugging purposes.  
  156. #
  157. # (maybe this should be made into a generic function?)  
  158. def GrammarBuild():
  159.     import kjParseBuild
  160.  
  161.     # initialize a Null compilable grammar to define
  162.     LispG = kjParseBuild.NullCGrammar()
  163.     
  164.     # declare terminals for the grammar
  165.     DeclareTerminals(LispG)
  166.  
  167.     # declare the keywords for the grammar
  168.     # defun is not used, included here for demo purposes only
  169.     LispG.Keywords("setq defun")
  170.  
  171.     # Declare punctuations
  172.     # dot is not used here
  173.     LispG.punct("().")
  174.  
  175.     # Declare Nonterms
  176.     LispG.Nonterms("Value ListTail")
  177.  
  178.     # Declare comment forms
  179.     LispG.comments([LISPCOMMENTREGEX])
  180.  
  181.     # Declare rules
  182.     LispG.Declarerules(GRAMMARSTRING)
  183.  
  184.     # Compile the grammar
  185.     LispG.Compile()
  186.  
  187.     # Write the grammar to a file except for
  188.     # the function bindings (which must be rebound)
  189.     outfile = open(COMPILEDFILENAME, "w")
  190.     LispG.Reconstruct("LispG",outfile,"GRAMMAR")
  191.     outfile.close()
  192.  
  193.     # for debugging purposes only, bind the rules
  194.     # in the generated grammar
  195.     BindRules(LispG)
  196.  
  197.     # return the generated Grammar
  198.     return LispG
  199.  
  200. # this function initializes the compiled grammar from 
  201. # generated file.  
  202. def LoadLispG():
  203.     import TESTLispG2
  204.     # make sure we have most recent version (during debugging)
  205.     reload(TESTLispG2)
  206.     # evaluate the grammar function from generated file
  207.     LispG = TESTLispG2.GRAMMAR()
  208.     # bind the semantics functions
  209.     DeclareTerminals(LispG)
  210.     BindRules(LispG)
  211.     return LispG
  212.  
  213. ########## test grammar generation
  214.  
  215. # do generation
  216. Dummy = GrammarBuild()
  217.  
  218. # load the grammar from the file as LispG
  219. LispG = LoadLispG()
  220.  
  221. # declare an initial context, and do some tests.
  222. Context = { "x":3 }
  223. test1 = LispG.DoParse1( "()", Context)
  224. test2 = LispG.DoParse1( "(123)", Context)
  225. test3 = LispG.DoParse1( "(x)", Context)
  226. test4 = LispG.DoParse1( '" a string "', Context)
  227. test5 = LispG.DoParse1( "(setq y (1 2 3) )", Context )
  228. test6 = LispG.DoParse1( '(setq x ("a string" "another" 0))', Context )
  229. test7str = """
  230.   ; this is a lisp comment
  231.   (setq abc (("a" x)
  232.              ("b" (setq d 12))
  233.              ("c" y) ) ; another lisp comment
  234.   )
  235. """
  236. test7 = LispG.DoParse1( test7str, Context)
  237.